Terminal

Open a terminal (Windows) by looking for the Anaconda Prompt terminal.

Verify installation

Open a terminal / Anaconda Prompt and run:

conda --version
python --version
jupyter --version

Libraries

Install required packages/libraries to run your program

Why: Environments come clean and you choose the dependencies and libraries that will be run on that project.

conda activate econ
conda install pandas -y 
conda install numpy matplotlib seaborn jupyterlab openpyxl statsmodels scikit-learn -y

Libraries (pip)

Some packages are unavailable in the anaconda network. You install them with pip:

conda activate econ
pip install scikit-learn -y

Tip: Prefer conda install (faster, fewer build issues); use pip only when needed.

(Other packages are far more complex. You may need to download a wheel.)

Key Libraries

Ready to Launch!

conda activate econ
jupyter lab        # modern interface
# or
jupyter notebook   # classic notebook

Jupyter

First python program

Create a Notebook using the python kernel. We are ready to run our first program:

print("Hello world")

print(2+5)

Hello world
7

Variables, Types

What are variables?

Variables store information for later use.

country = "Bahamas"
gdp = 12_500
growth_rate = 0.032
island = True
print(country, gdp)
print(growth_rate, island)

Bahamas 12500
0.032 True

Warning: Variables are stored in your RAM

Data Types

a = 10 # integer
b = 3.14 # float
c = "Economics" # string
d = True # boolean
print(type(a), type(b), type(c), type(d))

<class 'int'> <class 'float'> <class 'str'> <class 'bool'>

Common types: - int: whole numbers - float: decimals - str: text - boolean: True/False

Printing variables as string

country = "Bahamas"
gdp = 12_500
growth_rate = 0.032
island = True
print(f"The country {country} has a GDP of {gdp} \n and a growth rate of {growth_rate*100}\%.")

The country Bahamas has a GDP of 12500 
 and a growth rate of 3.2\%.

Warning: Variables are stored in your RAM

Operations

gdp = 12_500
growth_rate = 0.032
gdp_2 = gdp*(1+growth_rate)

print(f"Bahamas grew {growth_rate*100}\% and now has a GDP of {gdp_2}")

Bahamas grew 3.2\% and now has a GDP of 12900.0

# It is a good practice to comment the code.
# We first define the variables
gdp_1 = 12_500
gdp_2 = 12_900

# And we can now calculate the growth rate:
growth = gdp_2/gdp_1 - 1

print(f"The growth rate was {growth*100}\%.")
# Or round up when printing
print( f"The growth rate was {round(growth*100,2)}\%.")
# Or, first define the rounded growth
growth = round(growth,2)
print( f"The growth rate was {growth*100}\%.")

The growth rate was 3.200000000000003\%.
The growth rate was 3.2\%.
The growth rate was 3.0\%.

Conditional statements

Python includes relation operators (>, <, >=, !=, ==, in, is, not, ~) that return booleans (True/False)

print(5+15 > 10)
print(5 + 15 < 10 )
print(2 >= 5)
print(2 == 4/2)
print("a" != "a")

True
False
False
True
False

We can use if, elif and else with the operators above.

x = "abc"
if type(x) == str : 
  print(f"x({x}) is a string")
else : 
  print(f"{x} is {type(x)}")

x(abc) is a string

Conditional statement example

#score = float(input("Enter your exam score: "))
score = 50

if score >= 90:
    print("Grade: A")
elif score >= 80:
    print("Grade: B")
elif score >= 70:
    print("Grade: C")
elif score >= 60:
    print("Grade: D")
else:
    print("Grade: F")

print("Program finished.")

Grade: F
Program finished.

Data structures (collections)

Data structures organize and store multiple values efficiently.
They are different from simple variables that hold only one value.

Loops

• for: iterate over a sequence (list, tuple, dictionary, string, range).

fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

apple
banana
cherry

• while: Repeats as long as a condition is true.

count = 0
while count < 5:
    print("Count is:", count)
    count += 1

Count is: 0
Count is: 1
Count is: 2
Count is: 3
Count is: 4

Some useful statements: break (stops the loop), continue (skips code on that iteration), pass (does nothing/placeholder)

Loops and Conditionals

for num in range(10):
    if num == 8:
        break  # Stop the loop completely
    elif num == 3:
        continue  # Skip number 3
    print(f"Number: {num}")

Number: 0
Number: 1
Number: 2
Number: 4
Number: 5
Number: 6
Number: 7

Functions

A function is a reusable block of code that performs a specific task.
It helps you avoid repetition and organize your program.

def greet(name):
    """This function greets the person passed in as a parameter."""
    print("Hello,", name)

greet("Diego")

Hello, Diego

return sends a value back from the function to the place where the function was called.

Function uses

Suppose that you want to run a model and save the results in a table, then do a different model and a table. Functions save space.

def make_table(values):
    """Return a list of (index, value) pairs as a simple table."""
    table = []
    for i, v in enumerate(values):
        table.append((i, v))
    return table

data = [200, -15, 100]
result = make_table(data)

print("Index | Value")
print("--------------")
for row in result:
    print(f"{row[0]:5} | {row[1]:6}")

Index | Value
--------------
    0 |    200
    1 |    -15
    2 |    100

Dataframes

Table-like structure (pandas library) with rows/columns

import pandas as pd
data = {
    "Country": ["Brazil", "Bahamas", "Mexico"],
    "GDP": [2.1, 0.015, 1.8],
    "Population": [214, 0.401, 130]
}
df = pd.DataFrame(data)
df

Importing

import pandas as pd
brent = pd.read_csv("session_1_files/eia_brent.csv")
# Quick preview
brent.head()

Importing various formats

Pandas supports many ways to import data.

# Excel file
pd.read_excel("session_1_files/data.xlsx")
# Text file
pd.read_table("session_1_files/data.txt")

Exporting

Saving data is easy.

import pandas as pd
data = {
    "Country": ["Brazil", "Bahamas", "Mexico"],
    "GDP": [2.1, 0.015, 1.8],
    "Population": [214, 0.401, 130]
}
df = pd.DataFrame(data)

df.to_csv("session_1_files/example.csv", index=False)
df.to_csv("session_1_files/example.txt", sep="\t", index=False)
df.to_excel("session_1_files/example.xlsx", index=False)
df.to_json("session_1_files/example.json", orient="records")

json is a very efficient format in data science that stores records as dictionaries

Data Formats

Data exploration

import pandas as pd
df = pd.read_csv("session_1_files/uscensus_trade.csv")

# Show first rows
df.head()

# Show last rows
df.tail()

DataFrame Summary

import pandas as pd
df = pd.read_csv("session_1_files/uscensus_trade.csv")

print("====================")
print("Data info:")
print(df.info()) # Column names, data types, missing values

print("====================")
print("Summary stats:")
print(df.describe()) # Summary stats for numeric columns

print("====================")
print("Size:")
print(df.shape) # (rows, columns)

print("====================")
print("Column/Variable names:")
print(df.columns) # List of column names

print("====================")
print("Data types:")
print(df.dtypes) # Data types of each column

DataFrame: info()

import pandas as pd
df = pd.read_csv("session_1_files/uscensus_trade.csv")
df.info()

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 481 entries, 0 to 480
Data columns (total 3 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   date         481 non-null    object 
 1   exports USA  481 non-null    float64
 2   imports USA  481 non-null    float64
dtypes: float64(2), object(1)
memory usage: 11.4+ KB

DataFrame: describe()

import pandas as pd
df = pd.read_csv("session_1_files/uscensus_trade.csv")
df.describe()

Selecting

Suppose your dataset has many columns and you want to see descriptive statistics of only one.

import pandas as pd
df = pd.read_csv("session_1_files/uscensus_trade.csv")
df['exports USA'].describe()

count    481.000000
mean      45.783287
std       44.591570
min        5.500000
25%       23.500000
50%       34.800000
75%       52.100000
max      381.395095
Name: exports USA, dtype: float64

Indexes

When dealing with time-series it is a good idea to state the preferred index

import pandas as pd
df = pd.read_csv("session_1_files/uscensus_trade.csv")
df.head()

Set Index

When dealing with time-series it is a good idea to state the preferred index

import pandas as pd
df = pd.read_csv(
    "session_1_files/uscensus_trade.csv", 
    index_col='date'
    )
df.head()

Manage dates

Sometimes we need to make sure a column is read as a date. Use pd.to_datetime()

import pandas as pd
df = pd.read_csv(
    "session_1_files/uscensus_trade.csv"
    )

print(f"The column type: {df['date'].dtype}")
df.date = pd.to_datetime(df['date'], format="%Y-%m-%d")
print(f"After transforming: {df['date'].dtype}")

The column type: object
After transforming: datetime64[ns]

This becomes useful when merging and standardizing a dataset.

Simple visualization

import pandas as pd
df = pd.read_csv( 
    "session_1_files/uscensus_trade.csv",
     index_col='date'
     )
df.plot()

Filtering

import pandas as pd
df = pd.read_csv( 
    "session_1_files/uscensus_trade.csv",
     index_col='date',
     parse_dates=True
     )
df[df.index>"2020-01-01"].plot()

Complex Filtering

import pandas as pd
df = pd.read_csv( 
    "session_1_files/uscensus_trade.csv",
     index_col='date',
     parse_dates=True
     )
df[ (df.index>"2020-01-01") & (df.index<"2024-01-01")].plot()

Also df.loc["2020-01-01":"2025-01-01"].plot()

Combining datasets: concat, merge, join

concat

merge

join

Reshaping

wide → long: melt()

import pandas as pd
df = pd.read_csv( 
    "session_1_files/uscensus_trade.csv",
     parse_dates=True
     )

long_df = pd.melt(df, id_vars='date', 
                  var_name="Type", value_name="Value")
long_df

Reshaping: long → wide: pivot()

import pandas as pd
df = pd.read_csv( 
    "session_1_files/uscensus_trade.csv",
     parse_dates=True
     )

long_df = pd.melt(df, id_vars='date', 
                  var_name="Type", value_name="Value")

wide_df = long_df.pivot(index="date", columns="Type", values="Value")
wide_df

Reshape: resample()

Transforms data into a different frequency (e.g. daily to monthly/quarterly)

import pandas as pd
import matplotlib.pyplot as plt

# Create a daily dataset
df = pd.read_csv(
    "session_1_files/eia_brent.csv",
    parse_dates= True,
    index_col = "date")

monthly_df = df.resample("M").mean()

plt.figure(figsize=(8,4))
plt.plot(df.index, df["brent price"], alpha=0.4, label="Daily")
plt.plot(monthly_df.index, monthly_df["brent price"], color="red", linewidth=2, label="Monthly")
plt.title("Daily vs. Monthly Brent price", fontsize=14, weight="bold")
plt.legend(frameon=False)
plt.show()

Resample: example

import pandas as pd
import matplotlib.pyplot as plt

# Create a daily dataset
df = pd.read_csv(
    "session_1_files/eia_brent.csv",
    parse_dates= True,
    index_col = "date")

monthly_df = df.resample("M").mean()

plt.figure(figsize=(8,4))
plt.plot(df.index, df["brent price"], alpha=0.4, label="Daily")
plt.plot(monthly_df.index, monthly_df["brent price"], color="red", linewidth=2, label="Monthly")
plt.title("Daily vs. Monthly Brent price", fontsize=14, weight="bold")
plt.legend(frameon=False)
plt.show()

Resample Frequencies

Aggregation functions

Loading and visualizing a dataset

• Load two datasets (GDP and stock index)
• Perform data cleaning (e.g., standardizing date formats, merging, reshape)
• Reshape/resample/merge as needed
• Calculate basic descriptive statistics
• Generate time series plot